#ifndef __M_SRV_H__
#define __M_SRV_H__

#include "db.hpp"
#include "matcher.hpp"
#include "online.hpp"
// #include "room.hpp"
#include "server.hpp"
#include "session.hpp"
#include "util.hpp"
#include <functional>

#define WWWROOT "./wwwroot"

class gobang_server
{
private:
    std::string _web_root; /*静态资源根目录 ./wwroot   /register.html -> ./wwwroot/register.html */
    wsserver_t _wssrv;
    user_table _ut;
    online_manager _om;
    room_manager _rm;
    session_manager _ssm;
    matcher _mm;

private:
    void file_handler(wsserver_t::connection_ptr &conn)
    {
        // 静态资源请求的处理
        // 1. 获取到请求uri-资源路径，了解客户端请求的页面文件名称
        websocketpp::http::parser::request req = conn->get_request();
        std::string uri = req.get_uri();
        // 2. 组合出文件的实际路径   相对根目录 + uri
        std::string realpath = _web_root + uri;
        // 3. 如果请求的是个目录，增加一个后缀  login.html,    /  ->  /login.html
        if (realpath.back() == '/')
        {
            realpath += "login.html";
        }
        // 4. 读取文件内容
        Json::Value resp_json;
        std::string body;
        bool ret = file_util::read(realpath, body);
        //  1. 文件不存在，读取文件内容失败，返回404
        if (ret == false)
        {
            body += "<html>";
            body += "<head>";
            body += "<meta charset='UTF-8'/>";
            body += "</head>";
            body += "<body>";
            body += "<h1> Not Found </h1>";
            body += "</body>";
            conn->set_status(websocketpp::http::status_code::not_found);
            conn->set_body(body);
            return;
        }
        // 5. 设置响应正文
        conn->set_body(body);
        conn->set_status(websocketpp::http::status_code::ok);
    }
    void http_resp(wsserver_t::connection_ptr &conn, bool result,
                   websocketpp::http::status_code::value code, const std::string &reason)
    {
        Json::Value resp_json;
        resp_json["result"] = result;
        resp_json["reason"] = reason;
        std::string resp_body;
        json_util::serialize(resp_json, resp_body);
        conn->set_status(code);
        conn->set_body(resp_body);
        conn->append_header("Content-Type", "application/json");
        return;
    }
    void register_handle(wsserver_t::connection_ptr &conn)
    {
        // 用户注册功能请求的处理
        // websocketpp::http::parser::request req = conn->get_request();
        // 1. 获取到请求正文
        std::string req_body = conn->get_request_body();
        // 2. 对正文进行json反序列化，得到用户名和密码
        Json::Value req_json;
        bool ret = json_util::unserialize(req_body, req_json);
        if (ret == false)
        {
            DLOG("反序列化注册信息失败");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请求的正文格式错误");
        }
        // 3. 进行数据库的用户新增操作
        if (req_json["username"].isNull() || req_json["password"].isNull())
        {
            DLOG("用户名密码不完整");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请输入用户名/密码");
        }
        ret = _ut.insert(req_json);
        if (ret == false)
        {
            DLOG("向数据库插入数据失败");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "用户名已经被占用!");
        }
        //  如果成功了，则返回200
        return http_resp(conn, true, websocketpp::http::status_code::ok, "注册用户成功");
    }
    void login_handle(wsserver_t::connection_ptr &conn)
    {
        // 用户登录功能请求的处理
        // 1. 获取请求正文，并进行json反序列化，得到用户名和密码
        std::string req_body = conn->get_request_body();
        Json::Value req_json;
        bool ret = json_util::unserialize(req_body, req_json);
        if (ret == false)
        {
            DLOG("反序列化登录信息失败");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请求的正文格式错误");
        }
        // 2. 校验正文完整性，进行数据库的用户信息验证
        if (req_json["username"].isNull() || req_json["password"].isNull())
        {
            DLOG("用户名密码不完整");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请输入用户名/密码");
        }
        ret = _ut.login(req_json);
        if (ret == false)
        {
            //  1. 如果验证失败，则返回400
            DLOG("用户名密码错误");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "用户名密码错误");
        }
        // 3. 如果验证成功，给客户端创建session
        uint64_t uid = req_json["id"].asUInt64();
        session_ptr ssp = _ssm.create_session(uid, LOGIN);
        if (ssp.get() == nullptr)
        {
            DLOG("创建会话失败");
            return http_resp(conn, false, websocketpp::http::status_code::internal_server_error, "创建会话失败");
        }
        _ssm.set_session_expire_time(ssp->get_ssid(), SESSION_TIMEOUT);
        // 4. 设置响应头部：Set-Cookie,将sessionid通过cookie返回
        std::string cookie_ssid = "SSID=" + std::to_string(ssp->get_ssid());
        conn->append_header("Set-Cookie", cookie_ssid);
        return http_resp(conn, true, websocketpp::http::status_code::ok, "登录成功");
    }
    
    void info_handle(wsserver_t::connection_ptr &conn)
    {
        // 1.获取请求信息中的Cookie，从Cookie中获取ssid
        std::string cookie_str = conn->get_request_header("Cookie");
        if (cookie_str.empty()) {
            // 如果没有Cookie，则返回错误，让用户重新登录
            return http_resp(conn, false, 
                websocketpp::http::status_code::bad_request, "没有Cookie，请先登录!");
        }
        std::string ssid;
        bool ret = get_val_from_cookie(cookie_str, "SSID",ssid);
        if (ret == false) {
            // 没有ssid，则返回错误，让用户重新登录
            return http_resp(conn, false, 
                websocketpp::http::status_code::bad_request, "Cookie中没有ssid，请先登录!");
        }
        // 2.在session管理中查找对应的会话信息
        session_ptr ssp = _ssm.get_session_by_ssid(std::stol(ssid));
        if (ssp.get() == nullptr) {
            // 如果没有找到session，则返回错误，让用户重新登录
            return http_resp(conn, false, 
                websocketpp::http::status_code::bad_request, "没有session，请先登录!");
        }
        // 3.从数据库中取出用户信息，序列化后发送给客户端
        uint64_t uid = ssp->get_user();
        Json::Value info_json;
        ret = _ut.select_by_id(uid, info_json);
        if(ret == false) {
            //获取用户信息失败，返回错误：找不到用户信息
            return http_resp(conn, false,  
                websocketpp::http::status_code::bad_request, "找不到用户信息，请先登录!");
        }
        std::string resp_body;
        json_util::serialize(info_json, resp_body);
        conn->set_body(resp_body);
        conn->append_header("Content-Type", "application/json");
        conn->set_status(websocketpp::http::status_code::ok);
        // 4.刷新session的过期时间
        DLOG("刷新session的过期时间");
        _ssm.set_session_expire_time(std::stol(ssid), SESSION_TIMEOUT);
    }
    // 查找cookie中的某一项
    bool get_val_from_cookie(const std::string cookie, const std::string key, std::string &val) {
        std::string sep = "; ";
        std::vector<std::string> cookie_strs;
        string_util::split(cookie, sep, cookie_strs);
        for (auto &str : cookie_strs) {
            std::vector<std::string> cookie_s;
            string_util::split(str, "=", cookie_s);
            if (cookie_s.size() != 2) { continue; }
            if (cookie_s[0] == key) {
                val = cookie_s[1];
                return true;
            }
        }
        return false;
    }
    void http_callback(websocketpp::connection_hdl hdl)
    {
        wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request();
        std::string method = req.get_method();
        std::string uri = req.get_uri();
        if (method == "POST" && uri == "/reg")
        {
            return register_handle(conn);
        }
        else if (method == "POST" && uri == "/login")
        {
            return login_handle(conn);
        }
        else if (method == "GET" && uri == "/info")
        {
            return info_handle(conn);
        }
        else
        {
            return file_handler(conn);
        }
    }
    /*websocket 长连接建立成功后的回调函数*/
    /*游戏大厅长连接建立成功*/
    void websocket_respond(wsserver_t::connection_ptr conn, Json::Value &resp_json) {
            std::string resp_body;
            json_util::serialize(resp_json, resp_body);
            conn->send(resp_body);
    }
    /*身份验证+获取session_ptr*/
    session_ptr get_session_from_cookie(wsserver_t::connection_ptr conn) {
        // 1.获取请求信息中的Cookie，从Cookie中获取ssid
        Json::Value resp_json;
        std::string cookie_str = conn->get_request_header("Cookie");
        if (cookie_str.empty()) {
            // 如果没有Cookie，则返回错误，让用户重新登录
            resp_json["optype"] = "hall_ready";
            resp_json["result"] = "false";
            resp_json["reason"] = "没有找到Cookie，请先登录!";
            websocket_respond(conn, resp_json);
            return session_ptr();
        }
        std::string ssid;
        bool ret = get_val_from_cookie(cookie_str, "SSID",ssid);
        if (ret == false) {
            // 没有ssid，则返回错误，让用户重新登录
            resp_json["optype"] = "hall_ready";
            resp_json["result"] = "false";
            resp_json["reason"] = "没有找到ssid，请先登录!";
            websocket_respond(conn, resp_json);
            return session_ptr();
        }
        // 2.在session管理中查找对应的会话信息
        session_ptr ssp = _ssm.get_session_by_ssid(std::stol(ssid));
        if (ssp.get() == nullptr) {
            // 如果没有找到session，则返回错误，让用户重新登录
            resp_json["optype"] = "hall_ready";
            resp_json["result"] = "false";
            resp_json["reason"] = "没有找到session，请先登录!";
            websocket_respond(conn, resp_json);
            return session_ptr();
        }
        return ssp;
    }
    void wsopen_game_hall(wsserver_t::connection_ptr conn) {
        Json::Value resp_json;
        // 1.登录验证-判断当前客户端是否登录成功
        session_ptr ssp = get_session_from_cookie(conn);
        if (ssp.get() == nullptr) {
            return;
        }
        // 2.判断当前客户端是否重复登录
        if (_om.is_in_game_hall(ssp->get_user()) || _om.is_in_game_room(ssp->get_user()) ) {
            resp_json["optype"] = "hall_ready";
            resp_json["result"] = "false";
            resp_json["reason"] = "用户重复登录!";
            return websocket_respond(conn, resp_json);
        }
        // 3.将当前客户端及其长连接加入到游戏大厅
       _om.enter_game_hall(ssp->get_user(), conn); 
        // 4.给客户端响应游戏大厅长连接建立信息
        resp_json["optype"] = "hall_ready";
        resp_json["result"] = "true";
        websocket_respond(conn, resp_json);
        // 5.将session设置为永久存在
        DLOG("设置session为永久存在");
        _ssm.set_session_expire_time(ssp->get_ssid(), SESSION_FOREVER);
    }
    void wsopen_game_room(wsserver_t::connection_ptr conn) {
        Json::Value resp_json;
        // 1.用户登录信息检验+session_ptr获取
        session_ptr ssp = get_session_from_cookie(conn);
        if (ssp.get() == nullptr) {
            return;
        }
        // 2.判断用户是否已经在在线用户管理的游戏大厅或游戏房间中了 - 在线用户管理
        if (_om.is_in_game_hall(ssp->get_user()) || _om.is_in_game_room(ssp->get_user())) {
            resp_json["optype"] = "room_ready";
            resp_json["result"] = false;
            resp_json["reason"] = "用户重复登录";
            return websocket_respond(conn, resp_json);
        }
        // 3.判断用户是否已经加入了游戏房间 - 房间管理
        room_ptr rp = _rm.find_room_by_uid(ssp->get_user());
        if (rp.get() == nullptr) {
            resp_json["optype"] = "room_ready";
            resp_json["result"] = false;
            resp_json["reason"] = "用户没有加入游戏房间";
            return websocket_respond(conn, resp_json);
        }
        // 4.将用户添加到在线用户管理的游戏房间中
        _om.enter_game_room(ssp->get_user(), conn);
        // 5.将session设置为永久
        _ssm.set_session_expire_time(ssp->get_ssid(), SESSION_FOREVER);
        // 6.响应成功信息
        resp_json["optype"] = "room_ready";
        resp_json["result"] = true;
        resp_json["room_id"] = (Json::UInt64)rp->id();
        resp_json["uid"] = (Json::UInt64)ssp->get_user();
        resp_json["white_id"] = (Json::UInt64)rp->get_white_user();
        resp_json["black_id"] = (Json::UInt64)rp->get_black_user();
        return websocket_respond(conn, resp_json);
    }

    void wsopen_callback(websocketpp::connection_hdl hdl)
    {
        // 获取连接对象
        wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        // 获取请求对象
        websocketpp::http::parser::request req = conn->get_request();
        // 根据请求对象判断是游戏大厅长连接还是游戏房间长连接
        std::string uri = req.get_uri();
        if (uri == "/hall") {
            // 游戏大厅长连接
            wsopen_game_hall(conn);
        }
        else if (uri == "/room") {
            // 游戏房间长连接
            wsopen_game_room(conn);
        }
        else {

        }

    }
    void wsclose_game_hall(wsserver_t::connection_ptr conn) {
        session_ptr ssp = get_session_from_cookie(conn);
        if (ssp.get() == nullptr) {
            return;
        }
       _om.exit_game_hall(ssp->get_user());
       // 2.更新session为临时的
       //DLOG("更新session为临时");
       _ssm.set_session_expire_time(ssp->get_ssid(), SESSION_TIMEOUT);
    }
    void wsclose_game_room(wsserver_t::connection_ptr conn) {
        // 获取会话信息，识别客户端
        session_ptr ssp = get_session_from_cookie(conn);
        if (ssp.get() == nullptr) {
            return;
        }
        // 1.从在线游戏房间管理中移出
        _om.exit_game_room(ssp->get_user());
        // 2.设置session 为临时
        _ssm.set_session_expire_time(ssp->get_ssid(), SESSION_TIMEOUT);
        // 3.将玩家从游戏房间中移出，当房间中没有玩家时房间自动销毁
        //DLOG("remove user %lu", ssp->get_user());
        _rm.remove_room_user(ssp->get_user());
    }
    void wsclose_callback(websocketpp::connection_hdl hdl)
    {
        // 获取连接对象
        wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        // 获取请求对象
        websocketpp::http::parser::request req = conn->get_request();
        // 根据请求对象判断是游戏大厅长连接还是游戏房间长连接
        std::string uri = req.get_uri();
        if (uri == "/hall") {
            // 游戏大厅长连接
            wsclose_game_hall(conn);
        }
        else if (uri == "/room") {
            // 游戏房间长连接
            wsclose_game_room(conn);
        }
        else {

        }
    }
   /*websocket 消息处理*/ 
   /*1.游戏大厅的websocket 消息处理*/ 
    void wsmsg_game_hall(wsserver_t::connection_ptr conn, wsserver_t::message_ptr msg) {
        // 1.身份验证 - 封装为一个函数
        session_ptr ssp = get_session_from_cookie(conn);
        if (ssp.get() == nullptr) {
            return;
        }
        // 2.请求消息内容获取
        std::string req_body = msg->get_payload();
        Json::Value req_json;
        std::string resp_body;
        Json::Value resp_json;
        bool ret = json_util::unserialize(req_body, req_json);
        if (ret == false) {
            resp_json["result"] = false;
            resp_json["reason"] = "请求消息信息解析失败!";
            json_util::serialize(resp_json, resp_body);
            conn->send(resp_body);
            return;
        }
        // 3.处理请求
        if (!req_json["optype"].isNull() && req_json["optype"].asString() == "match_start") {
            // 4.开始匹配请求
            // 1.uid加入匹配队列
            _mm.add(ssp->get_user());
            // 2.返回响应信息
            resp_json["optype"] = "match_start";
            resp_json["result"] = true;
            return websocket_respond(conn, resp_json);
        }
        else if (!req_json["optype"].isNull() && req_json["optype"].asString() == "match_stop") {
            // 5.停止匹配请求
            // 1.uid离开匹配队列
            ret = _mm.del(ssp->get_user());
            // 2.返回响应信息
            resp_json["optype"] = "match_stop";
            resp_json["result"] = true;
            return websocket_respond(conn, resp_json);
        }
        else {
            resp_json["optype"] = "unknow";
            resp_json["reason"] = "请求类型未知!";
            resp_json["result"] = false;
            return websocket_respond(conn, resp_json);
        }
    }
   /*2.游戏房间的websocket 消息处理*/ 
    void wsmsg_game_room(wsserver_t::connection_ptr conn, wsserver_t::message_ptr msg) {
        Json::Value resp_json;
        // 1.对客户端进行身份验证+获取session
        session_ptr ssp = get_session_from_cookie(conn);
        if (ssp.get() == nullptr) {
            return;
        }
        // 2.获取房间信息
        room_ptr rp = _rm.find_room_by_uid(ssp->get_user());
        if (rp.get() == nullptr) {
            resp_json["optype"] = "unknow";
            resp_json["result"] = false;
            resp_json["reaseon"] = "获取房间信息失败";
            return websocket_respond(conn, resp_json);
        }
        // 3.获取消息内容+反序列化
        Json::Value req_json;
        std::string req_body;
        req_body = msg->get_payload();
        bool ret = json_util::unserialize(req_body, req_json);
        if (ret == false) {
            resp_json["optype"] = "unknow";
            resp_json["result"] = false;
            resp_json["reaseon"] = "请求解析失败";
            return websocket_respond(conn, resp_json);
        }
        // 4.房间管理模块处理
        return rp->handle_request(req_json);
    }
    void wsmessage_callback(websocketpp::connection_hdl hdl, wsserver_t::message_ptr msg)
    {
        wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request();
        std::string uri = req.get_uri();
        if (uri == "/hall") {
            // 游戏大厅消息
            wsmsg_game_hall(conn, msg);
        }
        else if (uri == "/room") {
            wsmsg_game_room(conn, msg);
        }
        else {

        }
    }

public:
    gobang_server(const std::string &host,
                  const std::string &username,
                  const std::string &password,
                  const std::string &dbname,
                  uint16_t port = 3306,
                  const std::string wwwroot = WWWROOT)
        : _ut(host, username, password, dbname, port),
          _rm(&_ut, &_om),
          _mm(&_rm, &_ut, &_om),
          _ssm(&_wssrv),
          _web_root(wwwroot)
    {
        _wssrv.set_access_channels(websocketpp::log::alevel::none);
        _wssrv.init_asio();
        _wssrv.set_reuse_addr(true);
        _wssrv.set_http_handler(std::bind(&gobang_server::http_callback, this, std::placeholders::_1));
        _wssrv.set_open_handler(std::bind(&gobang_server::wsopen_callback, this, std::placeholders::_1));
        _wssrv.set_close_handler(std::bind(&gobang_server::wsclose_callback, this, std::placeholders::_1));
        _wssrv.set_message_handler(std::bind(&gobang_server::wsmessage_callback, this, std::placeholders::_1, std::placeholders::_2));
    }
    void start(uint16_t port)
    {
        _wssrv.listen(port);
        _wssrv.start_accept();
        _wssrv.run();
    }
};

#endif
